package demo;

import java.io.InputStream;
import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import com.alibaba.fastjson.JSON;
import com.wrench.elevator.tida.dao.ZZGLDao;
import com.wrench.elevator.tida.domain.District;

public class Main {
    public static void main(String[] args) throws Exception {
        //io加载配置文件
        InputStream in=Main.class.getResourceAsStream("/mybatis-cfg.xml");
       System.out.println(in);
        //用构建器构建一个inputstream
        SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(in);

        SqlSession session=factory.openSession();
     
        ZZGLDao dao=session.getMapper(ZZGLDao.class);
        List<District> ds= dao.getDistrictByWuyeId(3);
        
       
        System.out.println(JSON.toJSON(ds));

        //记得提交 不提交等于啥都没干
        session.commit();
        //关闭资源
        session.close();
        }
    }
//class AEStest {        
//    
//    public static void ps1() throws Exception {  
//        // TODO Auto-generated method stub  
//        String str = "admin杨晨";  
//        String key = "love1U;";  
//        String encrytStr;  
//        byte[] encrytByte;  
//          
//        byte[] byteRe = enCrypt(str,key);  
//          
//        //加密过的二进制数组转化成16进制的字符串  
//        encrytStr = parseByte2HexStr(byteRe);         
//        System.out.println("加密后："+encrytStr);  
//          
//        //加密过的16进制的字符串转化成二进制数组  
//        encrytByte = parseHexStr2Byte(encrytStr);         
//        System.out.println("解密后："+deCrypt(encrytByte,key));  
//          
//          
//    }  
//      
//    /** 
//     * 加密函数 
//     * @param content   加密的内容 
//     * @param strKey    密钥 
//     * @return          返回二进制字符数组 
//     * @throws Exception 
//     */  
//    public static byte[] enCrypt(String content,String strKey) throws Exception{  
//        KeyGenerator keygen;          
//        SecretKey desKey;  
//        Cipher c;         
//        byte[] cByte;  
//        String str = content;  
//          
//        keygen = KeyGenerator.getInstance("AES");  
//        keygen.init(128, new SecureRandom(strKey.getBytes()));  
//          
//        desKey = keygen.generateKey();        
//        c = Cipher.getInstance("AES");  
//          
//        c.init(Cipher.ENCRYPT_MODE, desKey);  
//          
//        cByte = c.doFinal(str.getBytes("UTF-8"));         
//          
//        return cByte;  
//    }  
//      
//    /** 解密函数 
//     * @param src   加密过的二进制字符数组 
//     * @param strKey  密钥 
//     * @return 
//     * @throws Exception 
//     */  
//    public static String deCrypt (byte[] src,String strKey) throws Exception{  
//        KeyGenerator keygen;          
//        SecretKey desKey;  
//        Cipher c;         
//        byte[] cByte;     
//          
//        keygen = KeyGenerator.getInstance("AES");  
//        keygen.init(128, new SecureRandom(strKey.getBytes()));  
//          
//        desKey = keygen.generateKey();  
//        c = Cipher.getInstance("AES");  
//          
//        c.init(Cipher.DECRYPT_MODE, desKey);  
//          
//          
//        cByte = c.doFinal(src);   
//          
//        return new String(cByte,"UTF-8");  
//    }  
//      
//      
//    /**2进制转化成16进制 
//     * @param buf 
//     * @return 
//     */  
//    public static String parseByte2HexStr(byte buf[]) {  
//        StringBuffer sb = new StringBuffer();  
//        for (int i = 0; i < buf.length; i++) {  
//            String hex = Integer.toHexString(buf[i] & 0xFF);  
//            if (hex.length() == 1) {  
//                hex = '0' + hex;  
//                }  
//            sb.append(hex.toUpperCase());  
//            }  
//        return sb.toString();  
//        }  
//      
//      
//    /**将16进制转换为二进制 
//     * @param hexStr 
//     * @return 
//     */       
//    public static byte[] parseHexStr2Byte(String hexStr) {   
//            if (hexStr.length() < 1)   
//                    return null;   
//            byte[] result = new byte[hexStr.length()/2];   
//            for (int i = 0;i< hexStr.length()/2; i++) {   
//                    int high = Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);   
//                    int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);   
//                    result[i] = (byte) (high * 16 + low);   
//            }   
//            return result;   
//    }
//}



 class Hex {  
	  
    /** 
     * 用于建立十六进制字符的输出的小写字符数组 
     */  
    private static final char[] DIGITS_LOWER = { '0', '1', '2', '3', '4', '5',  
            '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };  
  
    /** 
     * 用于建立十六进制字符的输出的大写字符数组 
     */  
    private static final char[] DIGITS_UPPER = { '0', '1', '2', '3', '4', '5',  
            '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };  
  
    /** 
     * 将字节数组转换为十六进制字符数组 
     *  
     * @param data 
     *            byte[] 
     * @return 十六进制char[] 
     */  
    public static char[] encodeHex(byte[] data) {  
        return encodeHex(data, true);  
    }  
  
    /** 
     * 将字节数组转换为十六进制字符数组 
     *  
     * @param data 
     *            byte[] 
     * @param toLowerCase 
     *            <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式 
     * @return 十六进制char[] 
     */  
    public static char[] encodeHex(byte[] data, boolean toLowerCase) {  
        return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);  
    }  
  
    /** 
     * 将字节数组转换为十六进制字符数组 
     *  
     * @param data 
     *            byte[] 
     * @param toDigits 
     *            用于控制输出的char[] 
     * @return 十六进制char[] 
     */  
    protected static char[] encodeHex(byte[] data, char[] toDigits) {  
        int l = data.length;  
        char[] out = new char[l << 1];  
        // two characters form the hex value.  
        for (int i = 0, j = 0; i < l; i++) {  
            out[j++] = toDigits[(0xF0 & data[i]) >>> 4];  
            out[j++] = toDigits[0x0F & data[i]];  
        }  
        return out;  
    }  
  
    /** 
     * 将字节数组转换为十六进制字符串 
     *  
     * @param data 
     *            byte[] 
     * @return 十六进制String 
     */  
    public static String encodeHexStr(byte[] data) {  
        return encodeHexStr(data, true);  
    }  
  
    /** 
     * 将字节数组转换为十六进制字符串 
     *  
     * @param data 
     *            byte[] 
     * @param toLowerCase 
     *            <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式 
     * @return 十六进制String 
     */  
    public static String encodeHexStr(byte[] data, boolean toLowerCase) {  
        return encodeHexStr(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);  
    }  
  
    /** 
     * 将字节数组转换为十六进制字符串 
     *  
     * @param data 
     *            byte[] 
     * @param toDigits 
     *            用于控制输出的char[] 
     * @return 十六进制String 
     */  
    protected static String encodeHexStr(byte[] data, char[] toDigits) {  
        return new String(encodeHex(data, toDigits));  
    }  
  
    /** 
     * 将十六进制字符数组转换为字节数组 
     *  
     * @param data 
     *            十六进制char[] 
     * @return byte[] 
     * @throws RuntimeException 
     *             如果源十六进制字符数组是一个奇怪的长度，将抛出运行时异常 
     */  
    public static byte[] decodeHex(char[] data) {  
  
        int len = data.length;  
  
        if ((len & 0x01) != 0) {  
            throw new RuntimeException("Odd number of characters.");  
        }  
  
        byte[] out = new byte[len >> 1];  
  
        // two characters form the hex value.  
        for (int i = 0, j = 0; j < len; i++) {  
            int f = toDigit(data[j], j) << 4;  
            j++;  
            f = f | toDigit(data[j], j);  
            j++;  
            out[i] = (byte) (f & 0xFF);  
        }  
  
        return out;  
    }  
  
    /** 
     * 将十六进制字符转换成一个整数 
     *  
     * @param ch 
     *            十六进制char 
     * @param index 
     *            十六进制字符在字符数组中的位置 
     * @return 一个整数 
     * @throws RuntimeException 
     *             当ch不是一个合法的十六进制字符时，抛出运行时异常 
     */  
    protected static int toDigit(char ch, int index) {  
        int digit = Character.digit(ch, 16);  
        if (digit == -1) {  
            throw new RuntimeException("Illegal hexadecimal character " + ch  
                    + " at index " + index);  
        }  
        return digit;  
    }  
  
    public static void main(String[] args) {  
        String srcStr = "a198";  
        String encodeStr = encodeHexStr(srcStr.getBytes());  
        String decodeStr = new String(decodeHex(encodeStr.toCharArray()));  
        System.out.println("转换前：" + srcStr);  
        System.out.println("转换后：" + encodeStr);  
        System.out.println("还原后：" + decodeStr);  
    }  
  
}  
